/*
* 用户管理模块
*/
const express = require('express');
const router = express.Router();
// 引入数据库
const db = require("../../config/db");
// 引入时间包
const moment = require("moment");
// 引入方法库
const { toCamelCase, toUnderlineCase, verifyToken} = require("../../config/utils");
// 引入日志
const log = require("../log");
//m密码使用md5模块进行的加密
const md5 = require('md5');

// 获取所有用户列表
router.get("/list", async (req, res) => {
    console.log("===========获取用户列表接口============");
    // 获取参数
    let { pageNum, pageSize, phonenumber, userName, status, params, deptId } = req.query;
    // 拼接sql语句
    let sql = "select * from sys_user";
    let sql_where = ` where 1=1`;
    if(phonenumber){
        sql_where += ` and phonenumber like '%${phonenumber}%'`;
    }
    if(userName){
        sql_where += ` and user_name like '%${userName}%'`;
    }
    if(status){
        sql_where += ` and status = '${status}'`;
    }
    if(deptId){
        sql_where += ` and dept_id = '${deptId}'`;
    }
    if(params){
        sql_where += ` and create_time between '${params['beginTime']}' and  '${params['endTime']}'`;
    }
    if(phonenumber || userName || status || params || deptId){
        sql += sql_where;
    }
    
    // 分页
    sql += ` limit ${(pageNum-1)*pageSize}, ${pageSize}`;
    // 查询数据库
    db.query("查询用户列表", sql, (err, result)=>{
        if(err){
            res.send({code: 500, msg: "查询用户列表失败", data: err});
            return;
        }
        // 查询总数
        db.query("查询用户总数", `select count(*) as count from sys_user ${sql_where}`, (err, count)=>{
            if(err){
                res.send({code: 500, msg: "查询用户总数失败", data: err});
                return;
            }
            if(result.length > 0){
                 // 变量Json数组key转成下划线第一个大写
                 result = result.map(item => {
                    return toCamelCase(item)
                })
                res.send({code: 200, msg: "查询用户列表成功", rows: result, total: count[0].count});
            }else{
                res.send({code: 200, msg: "查询用户列表成功", rows: [], total: 0});
            }
        })
    })
})

// 查询单个用户
router.get("/", (req, res) => {
    console.log("===========查询单个用户接口============");
    // 查询表单岗位列表，角色列表
    db.query("查询表单岗位列表", "select * from sys_post", (err, posts)=>{
        if(err){
            res.send({code: 500, msg: "查询表单岗位列表失败", data: err});
            return;
        }
        if(posts.length > 0){
            // 变量Json数组key转成下划线第一个大写
            posts = posts.map(item => {
                return toCamelCase(item)
            })
        }
        
        db.query("查询表单角色列表", "select * from sys_role", (err, roles)=>{
            if(err){
                res.send({code: 500, msg: "查询表单角色列表失败", data: err});
                return;
            }
            if(roles.length > 0){
                 // 变量Json数组key转成下划线第一个大写
                roles = roles.map(item => {
                    return toCamelCase(item)
                })
            }
            res.send({code: 200, msg: "查询表单角色列表成功", posts, roles});
        })
    })
})

// 查询单个用户
router.get(/^\/(\d+)$/, (req, res) => {
    console.log("===========查询单个用户接口，正则匹配============");
    // 获取参数
    let url_arr = req.url.split("/");
    const id = url_arr[url_arr.length - 1];
   
    db.query("查询单个用户", `select * from sys_user where user_id = ${id}`, (err, result)=>{
        if(err){
            res.send({code: 500, msg: "查询单个用户失败", data: err});
            return;
        }
        if(result.length > 0){
            // 变量Json数组key转成下划线第一个大写
            result = result.map(item => {
                return toCamelCase(item)
            })
            // 查询表单岗位列表，角色列表
            let data_p_r = {};
            db.query("查询表单岗位列表", "select * from sys_post", (err, posts)=>{
                
                if(err){
                    res.send({code: 500, msg: "查询表单岗位列表失败", data: err});
                    return;
                }
                if(posts.length > 0){
                    // 变量Json数组key转成下划线第一个大写
                    posts = posts.map(item => {
                        return toCamelCase(item)
                    })
                    data_p_r.posts = posts;
                }
                // 查询表单角色列表
                db.query("查询表单角色列表", "select * from sys_role", (err, roles)=>{
                    if(err){
                        res.send({code: 500, msg: "查询表单角色列表失败", data: err});
                        return;
                    }
                    if(roles.length > 0){
                         // 变量Json数组key转成下划线第一个大写
                        roles = roles.map(item => {
                            return toCamelCase(item)
                        })
                        data_p_r.roles = roles;
                    }
                    // 查询用户岗位
                    db.query("查询用户岗位", `select post_id from sys_user_post where user_id = ${id}`, (err, user_posts)=>{
                        if(err){
                            res.send({code: 500, msg: "查询用户岗位失败", data: err});
                            return;
                        }
                        data_p_r.postIds = user_posts.map(item=>item.post_id);
                        // 查询用户角色
                        db.query("查询用户角色", `select role_id from sys_user_role where user_id = ${id}`, (err, user_roles)=>{
                            if(err){
                                res.send({code: 500, msg: "查询用户角色失败", data: err});
                                return;
                            }
                            data_p_r.roleIds = user_roles.map(item=>item.role_id);
                            res.send({code: 200, msg: "查询单个用户成功", data: result[0], ...data_p_r});
                        })
                    })
                })
            })
            
        }else{
            res.send({code: 500, msg: "查询单个用户失败"});
        }
    })
})

// 新增用户
router.post("/", (req, res)=>{
    console.log("===========新增用户接口============");
    // 获取参数
    let {nickName, userName, password, status, phonenumber, email, sex, deptId, remark, roleIds, postIds} = req.body;
    // 获取创建人
    let {username} = verifyToken(req.headers.authorization);
    // 获取创建时间
    let createTime = moment().format("YYYY-MM-DD HH:mm:ss");
    // 判断用户昵称和用户名称是否重复
    db.query("查询用户昵称和用户名称是否重复", `select * from sys_user where nick_name = '${nickName}' or user_name = '${userName}'`, (err, sql_check_result)=>{
        if(err){
            res.send({code: 500, msg: "查询用户昵称和用户名称是否重复失败", data: err});
            return;
        }
        if(sql_check_result.length > 0){
            res.send({code: 500, msg: "用户昵称或用户名称已存在"});
            return;
        }
        // 插入数据库
        let sql = `insert into sys_user (nick_name, user_name, password, status, phonenumber, email, sex, dept_id, remark, create_by, create_time)
        values 
        ('${nickName}', '${userName}', '${md5(password)}', '${status}',  ${phonenumber ? "'"+phonenumber+"'" : null}, ${email ? "'"+email+"'" : null}, 
        ${sex ? "'"+sex+"'" : null}, ${deptId ? "'"+deptId+"'" : null}, ${remark ? "'"+remark+"'" : null}, 
        '${username}', '${createTime}')`;
        db.query("新增用户", sql, (err, result)=>{
            if(err){
                res.send({code: 500, msg: "新增用户失败", data: err});
                return;
            }
            if(result.affectedRows > 0){
                res.send({code: 200, msg: "新增用户成功"});
                // 获取新增用户id
                let userId = result.insertId;
                // 修改用户角色
                db.query("删除用户角色",`delete from sys_user_role where user_id in(${userId})`, (err, result)=>{
                    if(err){
                        console.log({code: 500, msg: "删除用户角色失败", data: err});
                        return;
                    }
                    console.log({code: 200, msg: "删除用户角色成功", data: []});
                    // 批量插入用户角色
                    if(!roleIds) return;
                    let sql = `insert into sys_user_role(user_id, role_id) values ?`;
                    let values = roleIds.map(item => [userId, item]);
                    console.log(values);
                    db.query("批量插入用户角色", sql, values, (err, result)=>{
                        if(err){
                            console.log({code: 500, msg: "批量插入用户角色失败", data: err});
                            return;
                        }
                        if(result.affectedRows > 0){
                            console.log({code: 200, msg: "批量插入用户角色成功", data: []});
                        }else{
                            console.log({code: 500, msg: "批量插入用户角色失败", data: []});
                        }
                    })
                })
                // 修改用户岗位
                db.query("删除用户岗位",`delete from sys_user_post where user_id in(${userId})`, (err, result)=>{
                    if(err){
                        console.log({code: 500, msg: "删除用户岗位失败", data: err});
                        return;
                    }
                    console.log({code: 200, msg: "删除用户岗位成功", data: []});
                    // 批量插入用户岗位
                    if(!postIds) return;
                    let sql = `insert into sys_user_post(user_id, post_id) values ?`;
                    let values = postIds.map(item => [userId, item]);
                    console.log(values);
                    db.query("批量插入用户岗位", sql, values, (err, result)=>{
                        if(err){
                            console.log({code: 500, msg: "批量插入用户岗位失败", data: err});
                            return;
                        }
                        if(result.affectedRows > 0){
                            console.log({code: 200, msg: "批量插入用户岗位成功", data: []});
                        }else{
                            console.log({code: 500, msg: "批量插入用户岗位失败", data: []});
                        }
                    })
                })
            }else{
                res.send({code: 500, msg: "新增用户失败"});
            }
        })
    })
})

// 修改用户
router.put("/", (req, res)=>{
    console.log("===========修改用户接口============");
    // 获取参数
    let {nickName, status, phonenumber, email, sex, deptId, remark, userId, roleIds, postIds} = req.body;
    // 获取修改人
    let {username} = verifyToken(req.headers.authorization);
    // 获取修改时间
    let updateTime = moment().format("YYYY-MM-DD HH:mm:ss");
    // 判断用户昵称和用户名称是否重复
    db.query("查询用户昵称和用户名称是否重复", `select * from sys_user where user_id != ${userId} and nick_name = '${nickName}'`, (err, result)=>{
        if(err){
            res.send({code: 500, msg: "查询用户昵称和用户名称是否重复失败", data: err});
            return;
        }
        if(result.length > 0){
            res.send({code: 500, msg: "用户名称已存在", data: []});
            return;
        }
        // 修改用户sql
        let sql = `update sys_user set nick_name = '${nickName}', status = '${status}', phonenumber = ${phonenumber ? "'"+phonenumber+"'" : null},
        email = ${email ? "'"+email+"'" : null}, sex = ${sex ? "'"+sex+"'" : null}, dept_id = ${deptId ? "'"+deptId+"'" : null}, 
        remark = ${remark ? "'"+remark+"'" : null}, update_by = '${username}', update_time = '${updateTime}'
        where user_id = '${userId}'`;
        db.query("修改用户", sql, (err, result)=>{
            if(err){
                res.send({code: 500, msg: "修改用户失败", data: err});
                return;
            }
            if(result.affectedRows > 0){
                res.send({code: 200, msg: "修改用户成功", data: []});
                // 修改用户角色
                db.query("删除用户角色",`delete from sys_user_role where user_id in(${userId})`, (err, result)=>{
                    if(err){
                        console.log({code: 500, msg: "删除用户角色失败", data: err});
                        return;
                    }
                    console.log({code: 200, msg: "删除用户角色成功", data: []});
                    // 批量插入用户角色
                    if(!roleIds) return;
                    let sql = `insert into sys_user_role(user_id, role_id) values ?`;
                    let values = roleIds.map(item => [userId, item]);
                    console.log(values);
                    db.query("批量插入用户角色", sql, values, (err, result)=>{
                        if(err){
                            console.log({code: 500, msg: "批量插入用户角色失败", data: err});
                            return;
                        }
                        if(result.affectedRows > 0){
                            console.log({code: 200, msg: "批量插入用户角色成功", data: []});
                        }else{
                            console.log({code: 500, msg: "批量插入用户角色失败", data: []});
                        }
                    })
                })
                // 修改用户岗位
                db.query("删除用户岗位",`delete from sys_user_post where user_id in(${userId})`, (err, result)=>{
                    if(err){
                        console.log({code: 500, msg: "删除用户岗位失败", data: err});
                        return;
                    }
                    console.log({code: 200, msg: "删除用户岗位成功", data: []});
                    // 批量插入用户岗位
                    if(!postIds) return;
                    let sql = `insert into sys_user_post(user_id, post_id) values ?`;
                    let values = postIds.map(item => [userId, item]);
                    console.log(values);
                    db.query("批量插入用户岗位", sql, values, (err, result)=>{
                        if(err){
                            console.log({code: 500, msg: "批量插入用户岗位失败", data: err});
                            return;
                        }
                        if(result.affectedRows > 0){
                            console.log({code: 200, msg: "批量插入用户岗位成功", data: []});
                        }else{
                            console.log({code: 500, msg: "批量插入用户岗位失败", data: []});
                        }
                    })
                })
            }else{
                res.send({code: 500, msg: "修改用户失败", data: []});
            }
        })
    })
})

// 删除用户
router.delete("/:id", (req, res) => {
    console.log("===========删除用户接口============");
    // 获取参数
    let {id} = req.params;
     // 拼接sql,删除多条数据
     let sql = `delete from sys_user where user_id in(${id})`;
    // 查询数据库
    db.query("删除用户", sql, (err, result) => {
        if (err) {
            res.send({code: 500, msg: "删除用户失败", data: err});
            return
        }
        if(result.affectedRows > 0){
            res.send({code: 200, msg: "删除用户成功"})
        }else{
            res.send({code: 500, msg: "删除用户失败"})
        }
    })
})

// 重置用户密码
router.put("/resetPwd", (req, res) => {
    console.log("===========重置用户密码接口============");
    // 获取参数
    let {userId, password} = req.body;
    // 获取修改人
    let {username} = verifyToken(req.headers.authorization);
    // 判断是不是超级管理员
    if(username != "admin"){
        res.send({code: 500, msg: "只有超级管理员才能重置密码"});
        return;
    }
    // 获取修改时间
    let updateTime = moment().format("YYYY-MM-DD HH:mm:ss");
    // 生成sql
    let sql = `update sys_user set password = '${md5(password)}', update_by = '${username}', update_time = '${updateTime}'  where user_id = '${userId}'`;
    // 查询数据库
    db.query("重置用户密码", sql, (err, result) => {
        if (err) {
            res.send({code: 500, msg: "重置用户密码失败", data: err});
            return
        }
        if(result.affectedRows > 0){
            res.send({code: 200, msg: "重置用户密码成功"})
        }else{
            res.send({code: 500, msg: "重置用户密码失败"})
        }
    })
})

// 查询授权角色
router.get("/authRole/:userId", (req, res) => {
    console.log("===========查询授权角色接口============");
    // 获取参数
    let {userId} = req.params;
    // 查询数据库
    db.query("查询授权角色", `select * from sys_user where user_id = '${userId}'`, (err, user_result) => {
        if (err) {
            res.send({code: 500, msg: "查询授权角色失败", data: err});
            return
        }
        if(user_result.length > 0){
            // 变量Json数组key转成下划线第一个大写
            user_result = user_result.map(item => {
                return toCamelCase(item)
            })
            // 查询权限表
            db.query("查询权限表", `select * from sys_role`, (err, result) => {
                if (err) {
                    res.send({code: 500, msg: "查询授权角色失败", data: err});
                    return
                }
                if(result.length > 0){
                    // 变量Json数组key转成下划线第一个大写
                    result = result.map(item => {
                        return toCamelCase(item)
                    })
                    let json = {user: user_result[0], roles: result, total: result.length}
                    res.send({code: 200, msg: "查询授权角色成功", ...json })
                }else{
                    res.send({code: 200, msg: "查询授权角色成功", user: user_result[0], roles: [], total: 0})
                }
            })
           
        }else{
            res.send({code: 200, msg: "查询授权角色成功", user: [], roles: [], total: 0})
        }
    })
})

// 保存授权角色
router.put("/authRole", (req, res) => {
    console.log("===========保存授权角色接口============");
    // 获取参数
    let {userId, roleIds} = req.query;
    // 查询是否存在相同值
    db.query("查询是否存在相同值", `select * from sys_user_role where user_id = '${userId}'`, (err, result) => {
        if (err) {
            res.send({code: 500, msg: "查询是否存在相同值失败", data: err});
            return
        }
        if(result.length > 0){
            // 更新当前用户角色
            db.query("更新当前用户角色", `update sys_user_role set role_id = '${roleIds}' where user_id = '${userId}'`, (err, result) => {
                if (err) {
                    res.send({code: 500, msg: "更新当前用户角色失败", data: err});
                    return
                }
                if(result.affectedRows > 0){
                    res.send({code: 200, msg: "更新当前用户角色成功"})
                }else{
                    res.send({code: 500, msg: "更新当前用户角色失败"})
                }
            })
        }else{
            // 插入数据库
            db.query("保存授权角色", `insert into sys_user_role (user_id, role_id) values('${userId}', '${roleIds}')`, (err, result) => {
                if (err) {
                    res.send({code: 500, msg: "插入授权角色失败", data: err});
                    return
                }
                if(result.affectedRows > 0){
                    res.send({code: 200, msg: "插入授权角色成功"})
                }else{
                    res.send({code: 500, msg: "插入授权角色失败"})
                }
            })
        }
        
    })
    
})

// 查询用户个人信息
router.get("/profile", (req, res) => {
    console.log("===========查询用户个人信息接口============");
    // 获取token
    let {username} = verifyToken(req.headers.authorization);
    // 根据用户名称查询用户信息，根据用户id查询用户角色
    let sql_user = `SELECT b.role_id,a.* FROM sys_user a 
    LEFT JOIN sys_user_role b ON a.user_id = b.user_id  
    where a.user_name = '${username}'`
    db.query("查询用户个人信息", sql_user, (err, user_result) => {
        if (err) {
            res.send({code: 500, msg: "查询用户个人信息失败", data: err});
            return
        }
        if(user_result.length > 0){
            // 变量Json数组key转成下划线第一个大写
            user_result = user_result.map(item => {
                return toCamelCase(item)
            })
            // 根据角色id查询角色名称 联合查询 部门名称
            let sql_role_dept = `select * from sys_role where role_id = '${user_result[0].roleId}'
            union all 
            select * from sys_dept where dept_id = '${user_result[0].deptId}'`
            db.query("查询角色名称", sql_role_dept, (err, role_result) => {
                if (err) {
                    res.send({code: 500, msg: "查询角色名称失败", data: err});
                    return
                }
                if(role_result.length > 0){
                    // 变量Json数组key转成下划线第一个大写
                    role_result = role_result.map(item => {
                        item.dept_name = item.role_sort
                        return toCamelCase(item)
                    })
                    let data = { ...user_result[0], roles: role_result[0], total: role_result.length, dept: role_result[1]}
                    res.send({code: 200, msg: "查询用户个人信息成功", data, roleGroup : role_result[0].roleName })
                }else{
                    res.send({code: 200, msg: "查询用户个人信息成功", user: user_result[0], roles: [], total: 0})
                }
            })
        }else{
            res.send({code: 200, msg: "查询用户个人信息成功", user: [], roles: [], total: 0})
        }
    })
})

// 修改个人信息
router.put("/profile", (req, res)=>{
    console.log("===========修改个人信息接口============");
    // 获取参数
    let {nickName, phonenumber, email, sex, userId} = req.body;
    // 获取修改人
    let {username} = verifyToken(req.headers.authorization);
    // 获取修改时间
    let updateTime = moment().format("YYYY-MM-DD HH:mm:ss");
    // 修改个人信息sql
    let sql = `update sys_user set nick_name = '${nickName}',  phonenumber = '${phonenumber}', email = '${email}',
    sex = '${sex}', update_by = '${username}', update_time = '${updateTime}'
    where user_id = ${userId}`;
    db.query("修改个人信息", sql, (err, result)=>{
        if(err){
            res.send({code: 500, msg: "修改个人信息失败", data: err});
            return;
        }
        if(result.affectedRows > 0){
            res.send({code: 200, msg: "修改个人信息成功", data: []});
        }else{
            res.send({code: 500, msg: "修改个人信息失败", data: []});
        }
    })
})

// 修改密码
router.put("/profile/updatePwd", (req, res)=>{
    console.log("===========修改密码接口============");
    // 获取参数
    let { oldPassword, newPassword } = req.query;
    // 获取修改人
    let { username } = verifyToken(req.headers.authorization);
    // 获取修改时间
    let updateTime = moment().format("YYYY-MM-DD HH:mm:ss");
    // 查询用户信息
    let sql_user = `select * from sys_user where user_name = '${username}'`;
    db.query("查询用户信息", sql_user, (err, user_result) => {
        if (err) {
            res.send({code: 500, msg: "查询用户信息失败", data: err});
            return
        }
        if(user_result.length > 0){
            // 验证密码是否正确
            if(user_result[0].password !== md5(oldPassword)){
                res.send({code: 500, msg: "原密码不正确", data: []});
                return;
            }
            // 修改密码sql
            let sql = `update sys_user set password = '${md5(newPassword)}', update_by = '${username}', update_time = '${updateTime}' 
            where user_id = ${user_result[0].user_id}`;
            db.query("修改密码", sql, (err, result)=>{
                if(err){
                    res.send({code: 500, msg: "修改密码失败", data: err}); 
                    return;
                }
                if(result.affectedRows > 0){
                    res.send({code: 200, msg: "修改密码成功", data: []});
                }else{
                    res.send({code: 500, msg: "修改密码失败", data: []});
                }
            })
        }
    })
})

module.exports = router;
